﻿// This is an open source non-commercial project. Dear PVS-Studio, please check it.
// PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com

// ReSharper disable CheckNamespace
// ReSharper disable ClassNeverInstantiated.Global
// ReSharper disable CommentTypo
// ReSharper disable IdentifierTypo
// ReSharper disable InconsistentNaming
// ReSharper disable StringLiteralTypo
// ReSharper disable UnusedParameter.Local

/*
 * Ars Magna project, http://arsmagna.ru
 */

#region Using directives

using System;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.ComponentModel;

using AM.Reporting.Utils;

#endregion

#nullable enable

namespace AM.Reporting.Gauge.Radial
{
    /// <summary>
    /// Represents a linear scale.
    /// </summary>
#if !DEBUG
    [DesignTimeVisible(false)]
#endif
    public class RadialScale : GaugeScale
    {
        #region Fields

        private float left;
        private float top;
        private float height;
        private float width;
        private float majorTicksOffset;
        private float minorTicksOffset;
        private PointF center;
        private float minorStep;
        private int sideTicksCount;
        private bool drawRight, drawLeft;

        #endregion // Fields

        #region Enums

        private enum HorAlign
        {
            Middle,
            Left,
            Right
        }

        private enum VertAlign
        {
            Bottom,
            Middle,
            Top
        }

        #endregion //Enums

        #region Properties

        [Browsable (false)]
        internal PointF AvrTick { get; private set; }

        [Browsable (false)]
        internal double StepValue { get; set; }

        [Browsable (false)]
        internal double AverageValue { get; set; }

        internal float MajorStep { get; set; }

        #endregion // Properties

        #region Constructors

        /// <summary>
        /// Initializes a new instance of the <see cref="RadialScale"/> class.
        /// </summary>
        /// <param name="parent">The parent gauge object.</param>
        public RadialScale (RadialGauge parent) : base (parent)
        {
            MajorTicks = new ScaleTicks (5, 2, Color.Black, 11);
            MinorTicks = new ScaleTicks (2, 1, Color.Black, 4);
            MajorStep = 27; //degree, 135/5
            minorStep = 5.4f; // degree, 27/5
            drawRight = true;
            drawLeft = true;
        }

        #endregion // Constructors

        #region Private Methods

        private bool isNegative (int i, bool isRightPart)
        {
            if (RadialUtils.IsSemicircle (Parent) || RadialUtils.IsQuadrant (Parent))
            {
                if (i <= sideTicksCount / 2)
                {
                    if (isRightPart)
                    {
                        if (RadialUtils.IsBottom (Parent) && RadialUtils.IsLeft (Parent))
                        {
                            return false;
                        }
                        else if (RadialUtils.IsBottom (Parent))
                        {
                            return false;
                        }
                        else if (RadialUtils.IsLeft (Parent))
                        {
                            return true;
                        }
                        else if (RadialUtils.IsRight (Parent))
                        {
                            return true; //!!!!!!!!!!!!!!!!!!
                        }
                        else
                        {
                            return true; //Check!!!!
                        }
                    }
                    else
                    {
                        if (RadialUtils.IsTop (Parent) && RadialUtils.IsLeft (Parent))
                        {
                            return true;
                        }
                        else if (RadialUtils.IsBottom (Parent))
                        {
                            return false;
                        }
                        else if (RadialUtils.IsLeft (Parent))
                        {
                            return false;
                        }
                        else if (RadialUtils.IsRight (Parent))
                        {
                            return false; //!!!!!!!!!!!!!!!!!!
                        }
                        else
                        {
                            return true; //Check!!!!
                        }
                    }
                }

                return false; //shouldn't be reached
            }
            else if (i > sideTicksCount / 2)
            {
                return false;
            }
            else
            {
                return true;
            }
        }

        private void DrawText (PaintEventArgs e, string text, Brush brush, float x, float y, HorAlign hAlign,
            VertAlign vAlign)
        {
            var g = e.Graphics;
            var font = RadialUtils.GetFont (e, Parent, Font);
            var strSize = RadialUtils.GetStringSize (e, Parent, Font, text);
            float dx = 0;
            float dy = 0;
            if (hAlign == HorAlign.Middle)
            {
                dx = -strSize.Width / 2;
            }
            else if (hAlign == HorAlign.Left)
            {
                dx = 0;
            }
            else if (hAlign == HorAlign.Right)
            {
                dx = -strSize.Width;
            }

            if (vAlign == VertAlign.Bottom)
            {
                dy = -strSize.Height;
            }
            else if (vAlign == VertAlign.Middle)
            {
                dy = -strSize.Height / 2;
            }
            else if (vAlign == VertAlign.Top)
            {
                dy = 0;
            }

            g.DrawString (text, font, brush, x + dx, y + dy);
        }

        private PointF GetTextPoint (PointF[] tick, float txtOffset, bool negativ, bool isRight)
        {
            var dx = Math.Abs (tick[1].X - tick[0].X);
            var dy = Math.Abs (tick[1].Y - tick[0].Y);
            var absA = (float)Math.Sqrt (Math.Pow (dx, 2) + Math.Pow (dy, 2)); //vectors length
            var sinAlpha = dy / absA;
            var cosAlpha = dx / absA;
            var absA1 = absA + txtOffset;
            var dx1 = Math.Abs (absA1 * cosAlpha);
            var dy1 = Math.Abs (absA1 * sinAlpha);
            float pointX;
            float pointY;
            if (negativ)
            {
                pointY = tick[1].Y - dy1;
            }
            else
            {
                pointY = tick[1].Y + dy1;
            }

            if (isRight)
            {
                pointX = tick[1].X + dx1;
            }
            else
            {
                pointX = tick[1].X - dx1;
            }

            return new PointF (pointX, pointY);
        }

        private void DrawMajorTicks (PaintEventArgs e)
        {
            center = (Parent as RadialGauge).Center;
            StepValue = (Parent.Maximum - Parent.Minimum) / (MajorTicks.Count - 1);
            if (RadialUtils.IsQuadrant (Parent))
            {
                StepValue *= 2;
            }

            AverageValue = Parent.Minimum + (Parent.Maximum - Parent.Minimum) / 2;

            var isRightPart = true;
            var isLeftPart = false;
            PointF txtPoint;

            var g = e.Graphics;
            var pen = e.Cache.GetPen (MajorTicks.Color, MajorTicks.Width * e.ScaleX, DashStyle.Solid);
            var brush = TextFill.CreateBrush (new RectangleF (Parent.AbsLeft * e.ScaleX, Parent.AbsTop * e.ScaleY,
                Parent.Width * e.ScaleX, Parent.Height * e.ScaleY), e.ScaleX, e.ScaleY);
            sideTicksCount = (MajorTicks.Count - 1) / 2;
            MajorTicks.Length = width / 12;

            var maxTxt = RadialUtils.GetStringSize (e, Parent, Font, Parent.Maximum.ToString());
            var minTxt = RadialUtils.GetStringSize (e, Parent, Font, Parent.Minimum.ToString());
            var maxTxtOffset = maxTxt.Height > maxTxt.Width ? maxTxt.Height : maxTxt.Width;
            var minTxtOffset = minTxt.Height > minTxt.Width ? minTxt.Height : minTxt.Width;
            majorTicksOffset = maxTxtOffset > minTxtOffset ? maxTxtOffset : minTxtOffset;

            var tick0 = new PointF[2];
            AvrTick = new PointF (left + width / 2, top + majorTicksOffset);

            //first tick
            tick0[0] = AvrTick;
            tick0[1] = new PointF (tick0[0].X, tick0[0].Y + MajorTicks.Length);

            double angle = 0;
            var horAlign = HorAlign.Middle;
            var vertAlign = VertAlign.Bottom;
            var startValue = AverageValue;
            if (RadialUtils.IsSemicircle (Parent))
            {
                drawRight = true;
                drawLeft = true;
                if (RadialUtils.IsBottom (Parent))
                {
                    angle = 180 * RadialGauge.Radians;
                    horAlign = HorAlign.Middle;
                    vertAlign = VertAlign.Top;
                    MajorStep *= -1;
                    isRightPart = true;
                    isLeftPart = false;
                }
                else if (RadialUtils.IsLeft (Parent))
                {
                    angle = -90 * RadialGauge.Radians;
                    horAlign = HorAlign.Right;
                    vertAlign = VertAlign.Middle;
                    isRightPart = false;
                    isLeftPart = false;
                }
                else if (RadialUtils.IsRight (Parent))
                {
                    angle = 90 * RadialGauge.Radians;
                    horAlign = HorAlign.Left;
                    vertAlign = VertAlign.Middle;
                    MajorStep *= -1;
                    isRightPart = true; //false
                    isLeftPart = true; // false
                }
            }


            else if (RadialUtils.IsQuadrant (Parent))
            {
                if (RadialUtils.IsTop (Parent) && RadialUtils.IsLeft (Parent))
                {
                    startValue = Parent.Maximum;

                    //angle = 180 * RadialGauge.Radians;
                    horAlign = HorAlign.Middle;
                    vertAlign = VertAlign.Bottom;

                    //majorStep *= -1;
                    //isRightPart = true;
                    //isLeftPart = false;
                    drawRight = false;
                    drawLeft = true;

                    isRightPart = false;
                    isLeftPart = false;
                }
                else if (RadialUtils.IsBottom (Parent) && RadialUtils.IsLeft (Parent))
                {
                    startValue = Parent.Minimum;
                    angle = 180 * RadialGauge.Radians;
                    horAlign = HorAlign.Middle;
                    vertAlign = VertAlign.Top;
                    drawRight = true;
                    drawLeft = false;

                    isRightPart = false;
                    isLeftPart = false;
                }
                else if (RadialUtils.IsTop (Parent) && RadialUtils.IsRight (Parent))
                {
                    StepValue *= -1;
                    startValue = Parent.Maximum;
                    angle = 0;
                    horAlign = HorAlign.Middle;
                    vertAlign = VertAlign.Bottom;
                    drawRight = true;
                    drawLeft = false;

                    isRightPart = true;
                    isLeftPart = true;
                }
                else if (RadialUtils.IsBottom (Parent) && RadialUtils.IsRight (Parent))
                {
                    StepValue *= -1;
                    startValue = Parent.Minimum;
                    angle = 180 * RadialGauge.Radians;
                    horAlign = HorAlign.Middle;
                    vertAlign = VertAlign.Top;
                    drawRight = false;
                    drawLeft = true;

                    isRightPart = true;
                    isLeftPart = true;
                }
            }
            else
            {
                drawRight = true;
                drawLeft = true;
            }

            tick0 = RadialUtils.RotateVector (tick0, angle, center);

            g.DrawLine (pen, tick0[0].X, tick0[0].Y, tick0[1].X, tick0[1].Y);
            var text = startValue.ToString();
            DrawText (e, text, brush, tick0[0].X, tick0[0].Y, horAlign, vertAlign);

            //rest of ticks
            var tick = new PointF[2];
            angle = MajorStep * RadialGauge.Radians;

            for (var i = 0; i < sideTicksCount; i++)
            {
                //right side
                if (drawRight)
                {
                    tick = RadialUtils.RotateVector (tick0, angle, center);
                    g.DrawLine (pen, tick[0].X, tick[0].Y, tick[1].X, tick[1].Y);
                    text = Convert.ToString (Math.Round (startValue + StepValue * (i + 1)));

                    if (i == sideTicksCount / 2)
                    {
                        if (RadialUtils.IsSemicircle (Parent) || RadialUtils.IsQuadrant (Parent))
                        {
                            if (RadialUtils.IsLeft (Parent) && RadialUtils.IsTop (Parent))
                            {
                                horAlign = HorAlign.Right;
                                vertAlign = VertAlign.Middle;
                            }
                            else if (RadialUtils.IsLeft (Parent) && RadialUtils.IsBottom (Parent))
                            {
                                horAlign = HorAlign.Right;
                                vertAlign = VertAlign.Middle;
                            }
                            else if (RadialUtils.IsRight (Parent) && RadialUtils.IsTop (Parent))
                            {
                                horAlign = HorAlign.Left;
                                vertAlign = VertAlign.Middle;
                            }
                            else if (RadialUtils.IsLeft (Parent))
                            {
                                horAlign = HorAlign.Middle;
                                vertAlign = VertAlign.Bottom;
                            }
                            else if (RadialUtils.IsRight (Parent))
                            {
                                horAlign = HorAlign.Middle;
                                vertAlign = VertAlign.Bottom;
                            }
                            else
                            {
                                horAlign = HorAlign.Left;
                                vertAlign = VertAlign.Middle;
                            }
                        }
                        else
                        {
                            horAlign = HorAlign.Left;
                            vertAlign = VertAlign.Middle;
                        }
                    }
                    else if (i < sideTicksCount / 2)
                    {
                        horAlign = HorAlign.Left;
                        if (RadialUtils.IsSemicircle (Parent) || RadialUtils.IsQuadrant (Parent))
                        {
                            if (RadialUtils.IsLeft (Parent) && RadialUtils.IsTop (Parent))
                            {
                                horAlign = HorAlign.Right;
                                vertAlign = VertAlign.Middle;
                            }

                            if (RadialUtils.IsLeft (Parent) && RadialUtils.IsBottom (Parent))
                            {
                                vertAlign = VertAlign.Top;
                                horAlign = HorAlign.Right;
                            }
                            else if (RadialUtils.IsBottom (Parent))
                            {
                                vertAlign = VertAlign.Top;
                            }
                            else if (RadialUtils.IsLeft (Parent))
                            {
                                horAlign = HorAlign.Right;
                                vertAlign = VertAlign.Bottom;
                            }
                            else if (RadialUtils.IsRight (Parent))
                            {
                                horAlign = HorAlign.Left;
                                vertAlign = VertAlign.Bottom;
                            }
                        }
                        else
                        {
                            vertAlign = VertAlign.Bottom;
                        }
                    }
                    else
                    {
                        horAlign = HorAlign.Left;
                        vertAlign = VertAlign.Top;
                    }

                    txtPoint = GetTextPoint (tick, -1 * e.ScaleX, isNegative (i, true), isRightPart);
                    DrawText (e, text, brush, txtPoint.X, txtPoint.Y, horAlign, vertAlign);
                }

                if (drawLeft)
                {
                    //left side
                    angle *= -1;
                    tick = RadialUtils.RotateVector (tick0, angle, center);
                    g.DrawLine (pen, tick[0].X, tick[0].Y, tick[1].X, tick[1].Y);
                    text = Convert.ToString (Math.Round (startValue - StepValue * (i + 1)));

                    if (i == sideTicksCount / 2)
                    {
                        if (RadialUtils.IsSemicircle (Parent) || RadialUtils.IsQuadrant (Parent))
                        {
                            if ((RadialUtils.IsTop (Parent) || RadialUtils.IsBottom (Parent)) &&
                                RadialUtils.IsSemicircle (Parent))
                            {
                                horAlign = HorAlign.Right;
                                vertAlign = VertAlign.Middle;
                            }
                            else if (RadialUtils.IsLeft (Parent) && RadialUtils.IsTop (Parent))
                            {
                                horAlign = HorAlign.Right;
                                vertAlign = VertAlign.Middle;
                            }
                            else if (RadialUtils.IsRight (Parent) && RadialUtils.IsBottom (Parent))
                            {
                                horAlign = HorAlign.Left;
                                vertAlign = VertAlign.Middle;
                            }
                            else if (RadialUtils.IsLeft (Parent))
                            {
                                horAlign = HorAlign.Middle;
                                vertAlign = VertAlign.Top;
                            }
                            else if (RadialUtils.IsRight (Parent))
                            {
                                horAlign = HorAlign.Middle;
                                vertAlign = VertAlign.Top;
                            }
                        }
                        else
                        {
                            horAlign = HorAlign.Right;
                            vertAlign = VertAlign.Middle;
                        }
                    }
                    else if (i < sideTicksCount / 2)
                    {
                        horAlign = HorAlign.Right;

                        if (RadialUtils.IsSemicircle (Parent) || RadialUtils.IsQuadrant (Parent))
                        {
                            if (RadialUtils.IsRight (Parent) && RadialUtils.IsBottom (Parent))
                            {
                                vertAlign = VertAlign.Top;
                                horAlign = HorAlign.Left;
                            }
                            else if (RadialUtils.IsTop (Parent) && RadialUtils.IsLeft (Parent))
                            {
                                vertAlign = VertAlign.Bottom;
                                horAlign = HorAlign.Right;
                            }
                            else if (RadialUtils.IsBottom (Parent))
                            {
                                vertAlign = VertAlign.Top;
                            }
                            else if (RadialUtils.IsLeft (Parent))
                            {
                                horAlign = HorAlign.Right;
                                vertAlign = VertAlign.Top;
                            }
                            else if (RadialUtils.IsRight (Parent))
                            {
                                horAlign = HorAlign.Left;
                                vertAlign = VertAlign.Top;
                            }
                        }
                        else
                        {
                            vertAlign = VertAlign.Bottom;
                        }
                    }
                    else
                    {
                        horAlign = HorAlign.Right;
                        vertAlign = VertAlign.Top;
                    }

                    txtPoint = GetTextPoint (tick, -1 * e.ScaleX, isNegative (i, false), isLeftPart);
                    DrawText (e, text, brush, txtPoint.X, txtPoint.Y, horAlign, vertAlign);
                    angle *= -1;
                }

                angle += MajorStep * RadialGauge.Radians;
            }
        }

        private void DrawMinorTicks (PaintEventArgs e)
        {
            var g = e.Graphics;
            var pen = e.Cache.GetPen (MinorTicks.Color, MinorTicks.Width * e.ScaleX, DashStyle.Solid);

            MinorTicks.Length = width / 24;
            minorTicksOffset = majorTicksOffset + MajorTicks.Length / 2 - MinorTicks.Length / 2;
            var center = new PointF (left + width / 2, top + height / 2);

            var tick0 = new PointF[2];

            //first tick
            tick0[0] = new PointF (left + width / 2, top + minorTicksOffset);
            tick0[1] = new PointF (tick0[0].X, tick0[0].Y + MinorTicks.Length);

            double angle = 0;
            if (RadialUtils.IsSemicircle (Parent) || RadialUtils.IsQuadrant (Parent))
            {
                if (RadialUtils.IsBottom (Parent) && RadialUtils.IsLeft (Parent))
                {
                    angle = -180 * RadialGauge.Radians;
                }
                else if (RadialUtils.IsTop (Parent) && RadialUtils.IsLeft (Parent))
                {
                    angle = 0;
                }
                else if (RadialUtils.IsTop (Parent) && RadialUtils.IsRight (Parent))
                {
                    angle = 0;
                }
                else if (RadialUtils.IsBottom (Parent))
                {
                    angle = 180 * RadialGauge.Radians;
                    MajorStep *= -1;
                }
                else if (RadialUtils.IsLeft (Parent))
                {
                    angle = -90 * RadialGauge.Radians;
                }
                else if (RadialUtils.IsRight (Parent))
                {
                    angle = 90 * RadialGauge.Radians;
                    MajorStep *= -1;
                }
            }

            tick0 = RadialUtils.RotateVector (tick0, angle, center);

            //rest of ticks
            var tick = new PointF[2];
            angle = minorStep * RadialGauge.Radians;
            for (var i = 0; i < MajorTicks.Count / 2 * (MinorTicks.Count + 1); i++)
            {
                if ((i + 1) % (MinorTicks.Count + 1) != 0)
                {
                    if (drawRight)
                    {
                        tick = RadialUtils.RotateVector (tick0, angle, center);
                        g.DrawLine (pen, tick[0].X, tick[0].Y, tick[1].X, tick[1].Y);
                    }

                    if (drawLeft)
                    {
                        angle *= -1;
                        tick = RadialUtils.RotateVector (tick0, angle, center);
                        g.DrawLine (pen, tick[0].X, tick[0].Y, tick[1].X, tick[1].Y);
                        angle *= -1;
                    }
                }

                angle += minorStep * RadialGauge.Radians;
            }
        }

        #endregion // Private Methods

        #region Public Methods

        /// <inheritdoc/>
        public override void Assign (GaugeScale src)
        {
            base.Assign (src);

            var s = src as RadialScale;
            MajorTicks.Assign (s.MajorTicks);
            MinorTicks.Assign (s.MinorTicks);
        }

        /// <inheritdoc/>
        public override void Draw (PaintEventArgs e)
        {
            base.Draw (e);
            if ((Parent as RadialGauge).Type == RadialGaugeType.Circle)
            {
                MajorTicks.Count = 11;
                MinorTicks.Count = 4;
                MajorStep = 135f / 5;
                minorStep = 135f / 5f / 5f;
            }
            else if ((Parent as RadialGauge).Type == RadialGaugeType.Semicircle)
            {
                MajorTicks.Count = 5;
                MinorTicks.Count = 3;
                MajorStep = 90f / 2;
                minorStep = 90f / 2 / 4;
            }
            else if ((Parent as RadialGauge).Type == RadialGaugeType.Quadrant)
            {
                MajorTicks.Count = 5;
                MinorTicks.Count = 3;
                MajorStep = 90f / 2;
                minorStep = 90f / 2 / 4;
            }

            left = Parent.AbsLeft * e.ScaleX;
            top = Parent.AbsTop * e.ScaleY;
            height = Parent.Height * e.ScaleY;
            width = Parent.Width * e.ScaleX;
            DrawMajorTicks (e);
            DrawMinorTicks (e);
        }

        /// <inheritdoc/>
        public override void Serialize (ReportWriter writer, string prefix, GaugeScale diff)
        {
            base.Serialize (writer, prefix, diff);

            var dc = diff as RadialScale;
            MajorTicks.Serialize (writer, prefix + ".MajorTicks", dc.MajorTicks);
            MinorTicks.Serialize (writer, prefix + ".MinorTicks", dc.MinorTicks);
        }

        #endregion // Public Methods
    }
}
